const XunhuPayService = require('../services/xunhuPayService');
const { MaterialOrder } = require('../models'); // 假设有MaterialOrder模型
const { User } = require('../models'); // 假设有User模型
const { isMobileDevice } = require('../utils/tools');

// 初始化虎皮椒支付服务
const xunhuPayService = new XunhuPayService({
  appId: process.env.XUNHUPAY_APP_ID,
  appSecret: process.env.XUNHUPAY_APP_SECRET,
  notifyUrl: process.env.XUNHUPAY_NOTIFY_URL,
  returnUrl: process.env.XUNHUPAY_RETURN_URL
});

// 创建支付订单
exports.createOrder = async (req, res) => {
  try {
    const { orderNumber, paymentMethod } = req.body;
    const userId = req.user.id; // 假设从JWT中获取用户ID
    
    // 查找订单
    const order = await MaterialOrder.findOne({ 
      where: { orderNumber, userId }
    });
    
    if (!order) {
      return res.status(404).json({ message: '订单不存在' });
    }
    
    if (order.status !== 'pending') {
      return res.status(400).json({ message: '订单状态不允许支付' });
    }
    
    // 余额支付处理
    if (paymentMethod === 'balance') {
      const user = await User.findByPk(userId);
      
      if (user.balance < order.totalAmount) {
        return res.status(400).json({ message: '余额不足' });
      }
      
      // 扣除余额
      user.balance -= order.totalAmount;
      await user.save();
      
      // 更新订单状态
      order.status = 'paid';
      order.paidAt = new Date();
      order.paymentMethod = 'balance';
      await order.save();
      
      return res.json({ 
        success: true,
        message: '支付成功',
        orderStatus: 'paid'
      });
    }
    
    // 检测是否是移动设备
    const isMobile = isMobileDevice(req.headers['user-agent'] || '');
    
    // 虎皮椒支付处理
    let paymentResult;
    const payOptions = {
      orderId: order.orderNumber,
      amount: order.totalAmount,
      title: `材料订单 #${order.orderNumber}`,
      description: `材料购买订单`,
      isMobile
    };
    
    if (paymentMethod === 'wechat') {
      paymentResult = await xunhuPayService.createWxPay(payOptions);
    } else if (paymentMethod === 'alipay') {
      paymentResult = await xunhuPayService.createAliPay(payOptions);
    } else {
      return res.status(400).json({ message: '不支持的支付方式' });
    }
    
    // 保存支付ID到订单
    order.paymentId = paymentResult.paymentId;
    await order.save();
    
    res.json({
      success: true,
      qrCodeUrl: paymentResult.qrCodeUrl,
      payUrl: paymentResult.payUrl,
      paymentId: paymentResult.paymentId,
      isMobile
    });
    
  } catch (error) {
    console.error('创建支付订单失败:', error);
    res.status(500).json({ message: '创建支付订单失败', error: error.message });
  }
};

// 查询支付状态
exports.queryStatus = async (req, res) => {
  try {
    const { orderNumber } = req.params;
    
    // 查找订单
    const order = await MaterialOrder.findOne({ 
      where: { orderNumber }
    });
    
    if (!order) {
      return res.status(404).json({ message: '订单不存在' });
    }
    
    // 如果订单已支付，直接返回状态
    if (order.status === 'paid' || order.status === 'completed') {
      return res.json({
        success: true,
        status: 'paid',
        orderNumber: order.orderNumber
      });
    }
    
    // 查询虎皮椒支付状态
    const statusResult = await xunhuPayService.queryOrderStatus(order.orderNumber);
    
    if (statusResult.status === 'ok' && statusResult.trade_state === 'SUCCESS') {
      // 更新订单状态
      order.status = 'paid';
      order.paidAt = new Date();
      order.paymentMethod = statusResult.channel === 'wxpay' ? 'wechat' : 'alipay';
      await order.save();
      
      return res.json({
        success: true,
        status: 'paid',
        orderNumber: order.orderNumber
      });
    }
    
    res.json({
      success: true,
      status: 'pending',
      orderNumber: order.orderNumber
    });
    
  } catch (error) {
    console.error('查询支付状态失败:', error);
    res.status(500).json({ message: '查询支付状态失败', error: error.message });
  }
};

// 支付通知处理
exports.handleCallback = async (req, res) => {
  try {
    const notifyData = req.body;
    console.log('支付通知数据:', notifyData);
    
    // 验证通知签名
    if (!xunhuPayService.verifyNotify(notifyData)) {
      console.log('验签失败');
      return res.send('success'); // 虎皮椒要求返回success字符串
    }
    
    // 验证支付状态
    if (notifyData.status !== 'OD') { // OD表示支付成功
      console.log('支付未成功');
      return res.send('success');
    }
    
    // 查找并更新订单
    const order = await MaterialOrder.findOne({ 
      where: { orderNumber: notifyData.trade_order_id }
    });
    
    if (!order) {
      console.log('订单不存在');
      return res.send('success');
    }
    
    // 避免重复处理
    if (order.status === 'paid' || order.status === 'completed') {
      console.log('订单已处理');
      return res.send('success');
    }
    
    // 更新订单状态
    order.status = 'paid';
    order.paidAt = new Date();
    order.paymentMethod = notifyData.channel === 'wxpay' ? 'wechat' : 'alipay';
    order.paymentId = notifyData.trade_no;
    await order.save();
    
    console.log('订单支付成功:', order.orderNumber);
    
    // 返回成功
    res.send('success');
    
  } catch (error) {
    console.error('处理支付通知失败:', error);
    res.send('success'); // 即使处理失败也返回success，避免虎皮椒重复通知
  }
};

// 获取用户余额
exports.getUserBalance = async (req, res) => {
  try {
    const userId = req.user.id; // 假设从JWT中获取用户ID
    
    const user = await User.findByPk(userId, {
      attributes: ['balance']
    });
    
    if (!user) {
      return res.status(404).json({ message: '用户不存在' });
    }
    
    res.json({
      success: true,
      balance: user.balance
    });
    
  } catch (error) {
    console.error('获取用户余额失败:', error);
    res.status(500).json({ message: '获取用户余额失败', error: error.message });
  }
};

// 获取用户支付历史
exports.getUserPaymentHistory = async (req, res) => {
  try {
    const userId = req.user.id; // 假设从JWT中获取用户ID
    
    // 查询用户的所有已支付订单
    const orders = await MaterialOrder.findAll({
      where: {
        userId,
        status: ['paid', 'completed']
      },
      order: [['paidAt', 'DESC']],
      attributes: [
        'id', 
        'orderNumber', 
        'totalAmount', 
        'status', 
        'paymentMethod', 
        'paidAt', 
        'createdAt'
      ]
    });
    
    res.json({
      success: true,
      payments: orders
    });
    
  } catch (error) {
    console.error('获取支付历史失败:', error);
    res.status(500).json({ message: '获取支付历史失败', error: error.message });
  }
};